/* *******************************************************************
 * Copyright (c) 2002 Palo Alto Research Center, Incorporated (PARC).
 * All rights reserved.
 * This program and the accompanying materials are made available
 * under the terms of the Eclipse Public License v 2.0
 * which accompanies this distribution and is available at
 * https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.txt
 *
 * Contributors:
 *     PARC     initial implementation
 * ******************************************************************/

package org.aspectj.weaver.bcel;

import java.lang.reflect.Modifier;

import org.aspectj.weaver.Advice;
import org.aspectj.weaver.CommonWorldTests;
import org.aspectj.weaver.Member;
import org.aspectj.weaver.MemberImpl;
import org.aspectj.weaver.ResolvedMember;
import org.aspectj.weaver.ResolvedType;
import org.aspectj.weaver.ShadowMunger;
import org.aspectj.weaver.TestUtils;
import org.aspectj.weaver.UnresolvedType;
import org.aspectj.weaver.WeaverTestCase;
import org.aspectj.weaver.World;

/**
 * This is a test case for the nameType parts of worlds.
 */
public class WorldTestCase extends CommonWorldTests {

	private final BcelWorld world = new BcelWorld(WeaverTestCase.TESTDATA_PATH + "/tracing.jar");

	protected World getWorld() {
		return world;
	}

	protected boolean getSupportsAutoboxing() {
		return true;
	}

	// XXX fix the various XXXs before expecting this test to work
	public void xtestTraceJar() {
		ResolvedType trace = world.resolve(UnresolvedType.forName("Trace"), true);
		assertTrue("Couldnt find type Trace", !trace.isMissing());
		fieldsTest(trace, Member.NONE);
		/* Member constr = */TestUtils.methodFromString("void Trace.<init>()");
		// XXX need attribute fix -
		// methodsTest(trace, new Member[] { constr });

		interfacesTest(trace, ResolvedType.NONE);
		superclassTest(trace, UnresolvedType.OBJECT);
		isInterfaceTest(trace, false);
		isClassTest(trace, false);
		isAspectTest(trace, true);

		pointcutsTest(trace, new Member[] { MemberImpl.pointcut(trace, "traced", "(Ljava/lang/Object;)V"), });

		modifiersTest(trace.findPointcut("traced"), Modifier.PUBLIC | Modifier.ABSTRACT);

		mungersTest(
				trace,
				new ShadowMunger[] {
						BcelTestUtils.shadowMunger(world, "before(foo): traced(foo) -> void Trace.ajc_before_4(java.lang.Object))",
								0),
						BcelTestUtils
								.shadowMunger(
										world,
										"afterReturning(foo): traced(foo) -> void Trace.ajc_afterreturning_3(java.lang.Object, java.lang.Object))",
										Advice.ExtraArgument),
						BcelTestUtils
								.shadowMunger(
										world,
										"around(): execution(* doit(..)) -> java.lang.Object Trace.ajc_around_2(org.aspectj.runtime.internal.AroundClosure))",
										Advice.ExtraArgument),
						BcelTestUtils
								.shadowMunger(
										world,
										"around(foo): traced(foo) -> java.lang.Object Trace.ajc_around_1(java.lang.Object, org.aspectj.runtime.internal.AroundClosure))",
										Advice.ExtraArgument), });

		ResolvedType myTrace = world.resolve(UnresolvedType.forName("MyTrace"), true);
		assertTrue("Couldnt find type MyTrace", !myTrace.isMissing());

		interfacesTest(myTrace, ResolvedType.NONE);
		superclassTest(myTrace, trace);
		isInterfaceTest(myTrace, false);
		isClassTest(myTrace, false);
		isAspectTest(myTrace, true);

		// XXX need attribute fix -
		// fieldsTest(myTrace, Member.NONE);

		pointcutsTest(trace, new Member[] { MemberImpl.pointcut(trace, "traced", "(Ljava/lang/Object;)V"), });

		modifiersTest(myTrace.findPointcut("traced"), Modifier.PUBLIC);

		// this tests for declared mungers
		mungersTest(myTrace, ShadowMunger.NONE);

	}

	public void testIterator() {
		int abstractPublic = Modifier.ABSTRACT | Modifier.PUBLIC;
		ResolvedType iter = world.getCoreType(UnresolvedType.forRawTypeName("java.util.Iterator"));

		modifiersTest(iter, abstractPublic | Modifier.INTERFACE);
		fieldsTest(iter, ResolvedMember.NONE);
		methodsTest(iter, new Member[] {
				MemberImpl.method(iter, 0, "hasNext", "()Z"),
				MemberImpl.method(iter, 0, "remove", "()V"),
				MemberImpl.method(iter, 0, "next", "()Ljava/lang/Object;"),
				MemberImpl.method(iter, 0, "forEachRemaining", "(Ljava/util/function/Consumer;)V")
//				default void forEachRemaining(Consumer<? super E> action) {
//			        Objects.requireNonNull(action);
//			        while (hasNext())
//			            action.accept(next());
//			    }
				});
		ResolvedMember remove = iter.lookupMethod(MemberImpl.method(iter, 0, "remove", "()V"));
		assertNotNull("iterator doesn't have remove", remove);
		modifiersTest(remove, Modifier.PUBLIC); // no longer abstract in Java8 (default instead)
		exceptionsTest(remove, UnresolvedType.NONE);

		ResolvedMember clone = iter.lookupMethod(MemberImpl.method(UnresolvedType.OBJECT, 0, "clone", "()Ljava/lang/Object;"));
		assertNotNull("iterator doesn't have clone", clone);
		// AV: JRockit Object.clone() is not native.. corrupted test here:
		// modifiersTest(clone, Modifier.PROTECTED | Modifier.NATIVE);
		assertTrue("should be protected" + clone.toString(), Modifier.isProtected(clone.getModifiers()));
		exceptionsTest(clone, UnresolvedType.forNames(new String[] { "java.lang.CloneNotSupportedException" }));

		interfacesTest(iter, ResolvedType.NONE);
		superclassTest(iter, UnresolvedType.OBJECT);
		pointcutsTest(iter, ResolvedMember.NONE);
		mungersTest(iter, ShadowMunger.NONE);
		isInterfaceTest(iter, true);
		isClassTest(iter, false);
		isAspectTest(iter, false);
	}

	public void testObjectCoersion() {
		assertCouldBeCoercibleFrom("java.lang.Object", "java.lang.String");
		assertCouldBeCoercibleFrom("java.lang.Integer", "java.lang.Object");
		assertCouldBeCoercibleFrom("java.io.Serializable", "java.lang.Runnable");
		assertCouldBeCoercibleFrom("java.util.Stack", "java.lang.Runnable");
		assertCouldNotBeCoercibleFrom("java.lang.Runnable", "java.lang.Integer");
		assertCouldNotBeCoercibleFrom("java.lang.Integer", "java.lang.String");
		assertCouldNotBeCoercibleFrom("java.lang.Integer", "java.lang.Runnable");
	}

	// ----

	private void assertCouldBeCoercibleFrom(String a, String b) {
		isCoerceableFromTest(world.resolve(a), world.resolve(b), true);
	}

	private void assertCouldNotBeCoercibleFrom(String a, String b) {
		isCoerceableFromTest(world.resolve(a), world.resolve(b), false);
	}

}
